<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>learnArray</title>
</head>

<body>
    <script>
        // 数组声明方式
        var arr = new Array('luo', 'jian', 'ming');
        var arr1 = ['luo', 'jian', 'ming'];

        // 索引数组下标为数字，关联数组下标为字符串
        var myarr = [1, 'luo', { name: 'lisi' }];
        console.log(myarr[2].name);
        myarr['name'] = 'zhangsan';
        console.log(myarr.name);

        // ***数组，对象一般是地址传递（引用传递），数字，字符串，布尔是值传递
        var arr2 = arr1;
        arr2[3] = 666;
        console.log(arr1, arr2);//地址传递改变了一个，另一个也改变

        // 数组遍历
        var i = 0;
        while (i < arr1.length) {
            console.log(arr1[i]);
            i++;
        }
        for (let i = 0; i < arr1.length; i++) {
            console.log(arr1[i]);
        }
        // for...in...循环 index是数组下标
        for (let index in arr1) {
            console.log(index, arr1[index]);
        }
        // for...of...循环 value是数组元素的值
        for (let value of arr1) {
            console.log(value);
        }



        // 连接(合并)多个数组concat(),并返回一个新数组
        console.log(arr1.concat(arr, "111", ["22", "33"]));

        // 添加新元素到数组尾部push(),会改变原有数组
        arr1.push('handsome');
        console.log(arr1);

        // 删除数组尾部的一个元素，会改变原有数组
        arr1.pop();
        console.log(arr1);

        // 删除数组头部的一个元素，会改变原有数组
        arr1.shift();
        console.log(arr1);

        // 添加新元素到数组尾部unshift(),会改变原有数组
        arr1.unshift("luo", "666");
        console.log(arr1);

        // join方法將数组拼接为字符串,可以指定拼接符,不改变原有数组
        var str = arr1.join('');
        console.log(str);

        // reverse方法反转数组元素顺序，会改变原数组
        arr1.reverse();
        console.log(arr1);

        // slice方法截取数组的一部分并返回一个新数组，参数start~end，不包含end
        console.log(arr1.slice(1, 4));

        // splice方法添加修改删除数组元素,原数组会变,并返回剪切元素为一个新数组;
        // 参数start~length~element,length为要剪切的长度(个数)，elememt为要添加的元素
        var arr11 = arr1.splice(1, 4, 'luo', 'jian', 'ming', 888);
        console.log(arr1, arr11);

        //数组排序，sort()方法,会改变原数组，按ASCII码排序
        arr1.sort();
        console.log(arr1);
        var arrNum = [1, 2, 3, 6, 2, 8, 5, 4];
        // 冒泡排序：相邻两元素比较，把较大的数排在后面
        function maopao(a, b) {
            if (a > b) {
                return 1;
            } else if (a < b) {
                return -1;
            } else {
                return 0;
            }
        }
        console.log(arrNum.sort(maopao));

        // map()循环遍历数组，有返回值
        var res = arr1.map((value, index, arr) => {
            return value + 'map';
        })
        console.log(res);

        // forEach()循环遍历数组，无返回值
        arr1.forEach((value, index, arr) => {
            console.log(value, index, arr);
        })

        // filter()找到符合条件的所有元素,有返回值
        var res1 = arrNum.filter((value, index, arr) => {
            return value > 4;
        })
        console.log(res1);

        // find()找到符合条件的第一个元素,有返回值
        var res2 = arrNum.find((value, index, arr) => {
            return value > 4;
        })
        console.log(res2);

        // findIndex()找到符合条件的第一个元素的下标,有返回值
        var res3 = arrNum.findIndex((value, index, arr) => {
            return value > 2;
        })
        console.log(res3);

        // some() 只要一个元素符合条件就返回true
        var res4 = arrNum.some((value, index, arr) => {
            return value > 7;
        })
        console.log(res4);

        // every() 只要一个元素不符合条件就返回false
        var res5 = arrNum.every((value, index, arr) => {
            return value > 0;
        })
        console.log(res5);

        // includes() 是否包含指定的数组元素
        console.log(arr1.includes('luo'));

        // reduce()数组元素计算，规约(从左往右)
        var res6 = arrNum.reduce((total, value) => {
            return total + value;
        })
        console.log(res6);

        // reduceRight()数组元素计算，规约(从右往左)
        var res7 = arrNum.reduceRight((total, value) => {
            return total - value;
        })
        console.log(res7);

        //indexOf(),lastIndexOf()
        console.log(arr1.indexOf("luo"));
        console.log(arr1.lastIndexOf("luo"));



        // keys()返回所有数组元素下标组成的特殊对象
        for (let value of arr1.keys()) {
            console.log(value);
        }
        var keys = arr1.keys();
        console.log(keys)//keys是个迭代器（iterator）
        console.log(keys.next());
        console.log(keys.next());
        console.log(keys.next());
        console.log(keys.next());
        console.log(keys.next());
        console.log(keys.next());
        // values()返回所有数组元素的值组成的特殊对象
        for (let value of arr1.values()) {
            console.log(value);
        }
        var values = arr1.values();
        console.log(values.next());
        console.log(values.next());
        console.log(values.next());
        console.log(values.next());
        console.log(values.next());
        console.log(values.next());
        // entries()返回所有数组元素的键名、键值共同组成的特殊对象
        for (let value of arr1.entries()) {
            console.log(value);
        }
        var entries = arr1.entries();
        console.log(entries.next());
        console.log(entries.next());
        console.log(entries.next());
        console.log(entries.next());
        console.log(entries.next());
        console.log(entries.next());


        // 二维数组
        var arr2w = [
            ['luo', 'jian', 'ming'],
            ['haha', 111, 222],
            [333, 444, 555]
        ]
        console.log(arr2w[0][2]);

        // 选择排序 (每次排序把最小的放前面)
        // 外层循环，控制总的循环次数
        var numArr = [2, 4, 1, 8, 7, 5, 1, 0];
        // var num = 0;
        // for (let j = 0; j < numArr.length - 1; j++) {
        //     // 内层循环,每次拿数组的下一个元素,和后面所有的元素做比较
        //     for (var i = j; i < numArr.length - 1; i++) {
        //         if (numArr[j] > numArr[i + 1]) {
        //             num = numArr[j];
        //             numArr[j] = numArr[i + 1];
        //             numArr[i + 1] = num;
        //         }
        //     }
        //     console.log(numArr)
        // }


        // 冒泡排序 (每次排序把最大的放后面)
        var num = 0;
        // 外层循环, 控制总的排序次数
        for (var j = 0; j < numArr.length - 1; j++) {
            // 内层循环,每次拿数组的下一个元素,和它相邻的元素做比较,如果前面比后面大,就互换位置
            for (var i = 0; i < numArr.length - j - 1; i++) {
                if (numArr[i] > numArr[i + 1]) {
                    num = numArr[i];
                    numArr[i] = numArr[i + 1];
                    numArr[i + 1] = num;
                }
            }
            console.log(numArr);
        }


        //90到100的随机数
        console.log(90 + Math.floor(Math.random() * 11));

    </script>
</body>

</html>